# --- Function to test (copied and minimally adapted) ---

# imports
from matplotlib.pyplot import ioff

# --- Minimal stubs for matplotlib internals for testing ---


# Simulate matplotlib.rcParams as a global dict
class RcParams(dict):
    pass


# Simulate matplotlib module and its interactive state
class MatplotlibStub:
    def __init__(self):
        self.rcParams = RcParams()
        self.rcParams["interactive"] = False

    def interactive(self, b):
        self.rcParams["interactive"] = b

    def is_interactive(self):
        return self.rcParams["interactive"]


# Patch sys.modules to insert a dummy matplotlib module and _pylab_helpers
matplotlib = MatplotlibStub()

# --- Unit tests ---

# --- Basic Test Cases ---


def test_ioff_disables_interactive_mode():
    """
    Basic: ioff() disables interactive mode.
    """
    matplotlib.interactive(True)  # Start with interactive ON
    ioff()  # 8.31μs -> 4.71μs (76.5% faster)


def test_ioff_idempotent():
    """
    Basic: ioff() is idempotent (calling multiple times keeps interactive mode off).
    """
    matplotlib.interactive(True)
    ioff()  # 8.51μs -> 4.53μs (87.6% faster)
    ioff()  # 3.38μs -> 1.59μs (112% faster)


def test_ioff_returns_context_manager():
    """
    Basic: ioff() returns an AbstractContextManager.
    """
    codeflash_output = ioff()
    cm = codeflash_output  # 7.52μs -> 4.58μs (64.4% faster)


def test_ioff_context_manager_restores_state():
    """
    Basic: Using ioff() as a context manager restores previous interactive state.
    """
    matplotlib.interactive(True)
    with ioff():
        pass


def test_ioff_context_manager_nested():
    """
    Basic: Nested ioff() context managers restore state correctly.
    """
    matplotlib.interactive(True)
    with ioff():
        with ioff():
            pass


# --- Edge Test Cases ---


def test_ioff_when_already_off():
    """
    Edge: ioff() when interactive mode is already off.
    """
    matplotlib.interactive(False)
    ioff()  # 7.35μs -> 4.56μs (61.3% faster)


def test_ioff_context_manager_when_already_off():
    """
    Edge: Using ioff() as context manager when already off.
    """
    matplotlib.interactive(False)
    with ioff():
        pass


def test_ioff_context_manager_with_exception():
    """
    Edge: ioff() as context manager should restore state even if exception is raised.
    """
    matplotlib.interactive(True)
    try:
        with ioff():
            raise RuntimeError("Test exception")
    except RuntimeError:
        pass


def test_ioff_context_manager_many_nesting():
    """
    Large Scale: Test ioff() as context manager with many nested levels.
    """
    matplotlib.interactive(True)
    depth = 100  # Reasonable upper bound for test
    ctxs = []
    try:
        for _ in range(depth):
            codeflash_output = ioff()
            ctx = codeflash_output
            ctx.__enter__()
            ctxs.append(ctx)
    finally:
        while ctxs:
            ctx = ctxs.pop()
            ctx.__exit__(None, None, None)

# imports
from matplotlib.pyplot import ioff

# --- Function under test (simplified, self-contained for testing) ---


class DummyRcParams(dict):
    """A dummy rcParams dict for testing interactive state."""

    pass


class DummyMatplotlib:
    """A dummy matplotlib module with interactive state."""

    def __init__(self):
        self.rcParams = DummyRcParams()
        self.rcParams["interactive"] = False

    def interactive(self, b):
        self.rcParams["interactive"] = b

    def is_interactive(self):
        return self.rcParams["interactive"]


# Instantiate dummy global matplotlib object for test isolation
matplotlib = DummyMatplotlib()

# -------------------------
# Basic Test Cases
# -------------------------


def test_ioff_sets_interactive_false():
    """ioff() sets interactive mode to False."""
    matplotlib.interactive(True)
    ioff()  # 7.64μs -> 4.48μs (70.5% faster)


def test_ioff_when_already_false():
    """ioff() called when already False should remain False."""
    matplotlib.interactive(False)
    ioff()  # 7.64μs -> 4.64μs (64.5% faster)


def test_ioff_returns_context_manager():
    """ioff() returns an AbstractContextManager."""
    codeflash_output = ioff()
    cm = codeflash_output  # 7.60μs -> 4.52μs (68.2% faster)


def test_ioff_context_manager_restores_state():
    """ioff() used as context manager restores previous interactive state."""
    matplotlib.interactive(True)
    with ioff():
        pass


def test_ioff_context_manager_nested():
    """Nested ioff() context managers restore interactive state correctly."""
    matplotlib.interactive(True)
    with ioff():
        with ioff():
            pass


def test_ioff_multiple_calls_idempotent():
    """Multiple calls to ioff() keep interactive mode False."""
    matplotlib.interactive(True)
    ioff()  # 8.55μs -> 5.17μs (65.4% faster)
    ioff()  # 3.14μs -> 1.70μs (84.5% faster)


def test_ioff_context_manager_exception():
    """ioff context manager restores state even if exception is raised."""
    matplotlib.interactive(True)
    try:
        with ioff():
            raise RuntimeError("Test exception")
    except RuntimeError:
        pass


def test_ioff_many_nested_contexts():
    """Test ioff with many nested context managers (scalability)."""
    matplotlib.interactive(True)
    stack = []
    # Open 100 ioff contexts
    for _ in range(100):
        codeflash_output = ioff()
        cm = codeflash_output  # 235μs -> 140μs (67.8% faster)
        stack.append(cm.__enter__())
    # Close all contexts
    while stack:
        cm = stack.pop()
        cm.__exit__(None, None, None)


def test_ioff_context_manager_leak():
    """Test that ioff context manager does not leak state after many uses."""
    matplotlib.interactive(True)
    for _ in range(200):
        with ioff():
            pass


def test_ioff_context_manager_is_reentrant():
    """Test that ioff context manager can be re-entered."""
    matplotlib.interactive(True)
    codeflash_output = ioff()
    cm = codeflash_output  # 8.58μs -> 5.16μs (66.3% faster)
    with cm:
        pass
    with cm:
        pass


def test_ioff_context_manager_type():
    """Test that ioff returns a context manager of the correct base type."""
    codeflash_output = ioff()
    cm = codeflash_output  # 7.33μs -> 4.58μs (60.0% faster)


def test_ioff_docstring_present():
    """Test that ioff has a docstring."""


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.